﻿using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web;
using System.Web.Http;
using API.Models;

namespace API.Controllers
{
    public class KlachtController : ApiController
    {
        private KlachtContext db = new KlachtContext();

        /// <summary>
        /// Get all klachten
        /// </summary>
        /// <returns></returns>
        public IEnumerable<Klacht> GetKlachts()
        {
            return db.Klachts.AsEnumerable();
        }

        /// <summary>
        /// Get klacht met een specifiek id
        /// </summary>
        /// <param name="id">id van de klacht</param>
        /// <returns></returns>
        public Klacht GetKlacht(int id)
        {
            Klacht klacht = db.Klachts.Find(id);
            if (klacht == null)
            {
                throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
            }

            return klacht;
        }


        /// <summary>
        /// Get klachten op stad
        /// </summary>
        /// <param name="gemeente">naam van de stad</param>
        /// <returns></returns>
        public IEnumerable<Klacht> GetKlachtInCity(string gemeente)
        {
            List<Klacht> klachten = new List<Klacht>();
            var query = from k in db.Klachts
                        where k.Plaatsnaam == gemeente
                        select new
                        {
                            k
                        };
            foreach (var klachtResult in query)
            {
                Klacht klacht = new Klacht();
                if (klacht == null)
                {
                    throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
                }
                else
                {
                    klacht.Id = klachtResult.k.Id;
                    klacht.IngevoerdDoor = klachtResult.k.IngevoerdDoor;
                    klacht.Plaatsnaam = klachtResult.k.Plaatsnaam;
                    klacht.Postcode = klachtResult.k.Postcode;
                    klacht.Straatnaam = klachtResult.k.Straatnaam;
                    klacht.SubaardOverlast = klachtResult.k.SubaardOverlast;
                    klacht.SubsubaardOverlast = klachtResult.k.SubsubaardOverlast;
                    klacht.TerugkoppellingGevraagd = klachtResult.k.TerugkoppellingGevraagd;
                    klacht.Aantal = klachtResult.k.Aantal;
                    klacht.Aardoverlast = klachtResult.k.Aardoverlast;
                    klacht.DatumOverlast = klachtResult.k.DatumOverlast;
                    klachten.Add(klacht);
                }
            }
            return klachten.AsEnumerable<Klacht>();
        }

        /// <summary>
        /// get klachten op postcode
        /// </summary>
        /// <param name="postcode">in te vullen postcode</param>
        /// <returns></returns>
        public IEnumerable<Klacht> GetKlachtByPostcode(string postcode)
        {
            List<Klacht> klachten = new List<Klacht>();
            var query = from k in db.Klachts
                        where k.Postcode == postcode
                        select new
                        {
                            k.Id
                        };
            foreach (var klachtresult in query)
            {
                Klacht klacht = db.Klachts.Find(klachtresult.Id);
                if (klacht == null)
                {
                    throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
                }
                else
                {
                    klachten.Add(klacht);
                }
            }
            return klachten.AsEnumerable<Klacht>();
        }

        /// <summary>
        /// get klachten op aard
        /// </summary>
        /// <param name="aard">in te vullen aard</param>
        /// <returns></returns>
        public IEnumerable<Klacht> GetKlachtByAard(string aard)
        {
            List<Klacht> klachten = new List<Klacht>();
            var query = from k in db.Klachts
                        where k.Aardoverlast == aard
                        select new
                        {
                            k.Id
                        };
            foreach (var result in query)
            {
                Klacht klacht = db.Klachts.Find(result.Id);

                if (klacht == null)
                {
                    throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
                }
                else
                {
                    klachten.Add(klacht);
                }
            }
            return klachten.AsEnumerable<Klacht>();
        }

        /// <summary>
        /// get klachten op terugkoppeling
        /// </summary>
        /// <param name="terugkoppeling">alleen de waarden J of N zijn mogelijk, enig andere waarde genereert een not found error</param>
        /// <returns></returns>
        public IEnumerable<Klacht> GetKlachtByTerugkoppeling(string terugkoppeling)
        {
            List<Klacht> klachten = new List<Klacht>();
            var query = from k in db.Klachts
                        where k.TerugkoppellingGevraagd == terugkoppeling
                        select new
                        {
                            k.Id
                        };
            foreach (var result in query)
            {
                Klacht klacht = db.Klachts.Find(result.Id);
                if (klacht == null)
                {
                    throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
                }
                else
                {
                    klachten.Add(klacht);
                }
            }
            return klachten.AsEnumerable<Klacht>();
        }



        // PUT api/Klacht/5
        public HttpResponseMessage PutKlacht(int id, Klacht klacht)
        {
            if (!ModelState.IsValid)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }

            if (id != klacht.Id)
            {
                return Request.CreateResponse(HttpStatusCode.BadRequest);
            }

            db.Entry(klacht).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException ex)
            {
                return Request.CreateErrorResponse(HttpStatusCode.NotFound, ex);
            }

            return Request.CreateResponse(HttpStatusCode.OK);
        }

        // POST api/Klacht
        public HttpResponseMessage PostKlacht(Klacht klacht)
        {
            if (ModelState.IsValid)
            {
                db.Klachts.Add(klacht);
                db.SaveChanges();

                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, klacht);
                response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = klacht.Id }));
                return response;
            }
            else
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }
        }

        // DELETE api/Klacht/5
        [Authorize]
        public HttpResponseMessage DeleteKlacht(int id)
        {
            Klacht klacht = db.Klachts.Find(id);
            if (klacht == null)
            {
                return Request.CreateResponse(HttpStatusCode.NotFound);
            }

            db.Klachts.Remove(klacht);

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException ex)
            {
                return Request.CreateErrorResponse(HttpStatusCode.NotFound, ex);
            }

            return Request.CreateResponse(HttpStatusCode.OK, klacht);
        }

        protected override void Dispose(bool disposing)
        {
            db.Dispose();
            base.Dispose(disposing);
        }
    }
}